/**
 * 
 */
package com.redis.api;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * @author yangjuanying
 */
public interface DataWriter {
	
	/**
	 * 设置缓存，若已经存在索引数据，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @return
	 */
	public boolean set(byte[] key, byte[] value);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接忽略(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @return
	 */
	public boolean setnx(byte[] key, byte[] value);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接忽略(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @return
	 */
	public boolean setnx(String key, String value);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接忽略(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public boolean setnx(String key, String value, int expire);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public boolean set(byte[] key, byte[] value, int expire);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @return
	 */
	public boolean set(String key, String value);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public boolean set(String key, String value, int expire);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param value             待缓存的值
	 * @return
	 */
	public <T extends Serializable> boolean setBean(String key, T value);
	
	/**
	 * 设置缓存，若已经存在索引数据，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param value             待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public <T extends Serializable> boolean setBean(String key, T value, int expire);
	
	/**
	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @return
	 */
	public byte[] getSet(byte[] key, byte[] value);
	
	/**
	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public byte[] getSet(byte[] key, byte[] value, int expire);
	
	/**
	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @return
	 */
	public String getSet(String key, String value);
	
	/**
	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
	 * @param key               索引的key
	 * @param values            待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public String getSet(String key, String value, int expire);
	
	/**
	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
	 * @param key               索引的key
	 * @param value             待缓存的值
	 * @return
	 */
	public <T extends Serializable> T getSetBean(String key, T value);
	
	/**
	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
	 * @param key               索引的key
	 * @param value             待缓存的值
	 * @param expire            生存时间(秒)
	 * @return
	 */
	public <T extends Serializable> T getSetBean(String key, T value, int expire);
	
	/**
	 * 在给定key的值的后端追加新的值
	 * @param key               索引的key
	 * @param value             待追加的值
	 * @return                  追加完毕后数据的长度
	 */
	public long append(String key, byte[] value);
	
	/**
	 * 在给定key的值的后端追加新的值
	 * @param key               索引的key
	 * @param value             待追加的值
	 * @return                  追加完毕后数据的长度
	 */
	public long append(String key, String value);
	
	/**
	 * 批量设置缓存值(本方法K/V必须成对出现，否则执行发生异常),若已存在，直接覆盖
	 * @param kvs                 索引与数据
	 * @return
	 */
	public boolean mset(String... kvs);
	
	/**
	 * 批量设置缓存值(本方法K/V必须成对出现，否则执行发生异常)，若已存在，直接忽略
	 * @param kvs                 索引与数据
	 * @return                    成功设置的个数
	 */
	public long msetnx(String... kvs);
	
	/**
	 * 根据索引key删除缓存中对应的数据
	 * @param key               索引的key
	 * @return
	 */
	public boolean del(String key);
	
	/**
	 * 目标索引的计数器数字加一，本操作为原子操作
	 * @param key              索引的key
	 * @return                 递增后端值
	 */
	public long incr(String key);
	
	/**
	 * 目标索引的计数器数字加上步长(可正可负)，本操作为原子操作
	 * @param key             索引的key
	 * @param step            增长步长
	 * @return
	 */
	public long incrBy(String key, long step);
	
	/**
	 * 目标索引的计数器数字减一，本操作为原子操作
	 * @param key              索引的key
	 * @return                 递减后端值
	 */
	public long decr(String key);
	
	/**
	 * 目标索引的计数器数字加上步长(可正可负)，本操作为原子操作
	 * @param key             索引的key
	 * @param step            减少步长
	 * @return
	 */
	public long decrBy(String key, long step);
	
	/**
	 * 目标索引的计数器数字加上步长(可正可负)，本操作为原子操作
	 * @param key             索引的key
	 * @param step            递增步长
	 * @return
	 */
	public double incrByFloat(String key, double step);
	
	/**
	 * 设置索引key指向的hash表的指定域的缓存，若已经存在，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param field             hash表指定域
	 * @param value             待缓存的值
	 * @return
	 */
	public boolean hset(String key, String field, byte[] value);
	
	/**
	 * 设置索引key指向的hash表的指定域的缓存，若已经存在，直接忽略(数据永不过期)
	 * @param key               索引的key
	 * @param field             hash表指定域
	 * @param value             待缓存的值
	 * @return
	 */
	public boolean hsetnx(String key, String field, byte[] value);
	
	/**
	 * 设置索引key指向的hash表的指定域的缓存，若已经存在，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param field             hash表指定域
	 * @param value             待缓存的值
	 * @return
	 */
	public boolean hset(String key, String field, String value);
	
	/**
	 * 批量设置目标hash表到缓存，若已经存在，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param fieldValues       指定域和缓存的值
	 * @return
	 */
	public boolean hmset(String key, Map<String, String> fieldValues);
	
	/**
	 * 设置索引key指向的hash表的指定域的缓存，若已经存在，直接忽略(数据永不过期)
	 * @param key               索引的key
	 * @param field             hash表指定域
	 * @param value             待缓存的值
	 * @return
	 */
	public boolean hsetnx(String key, String field, String value);
	
	/**
	 * 设置索引key指向的hash表的指定域的缓存，若已经存在，直接覆盖(数据永不过期)
	 * @param key               索引的key
	 * @param field             hash表指定域
	 * @param value             待缓存的值
	 * @return
	 */
	public <T extends Serializable> boolean hsetBean(String key, String field, T value);
	
	/**
	 * 设置索引key指向的hash表的指定域的缓存，若已经存在，直接忽略(数据永不过期)
	 * @param key               索引的key
	 * @param field             hash表指定域
	 * @param value             待缓存的值
	 * @return
	 */
	public <T extends Serializable> boolean hsetnxBean(String key, String field, T value);
	
	/**
	 * 删除索引key指向的hash表的目标域
	 * @param key               索引的key
	 * @param fields            hash表指定域
	 * @return                  成功移除的域数量
	 */
	public long hdel(String key, String... fields);
	
	/**
	 * 对key索引的hash表中的指定域进行递增若干步长(可正可负)
	 * @param key               索引的key
	 * @param fields            hash表指定域
	 * @param step              递增补长
	 * @return                  最新数值
	 */
	public long hincrBy(String key, String field, long step);
	
	
	/**
	 * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
	 * @param key                索引的key
	 * @param members            要移除的目标元素 
	 * @return
	 */
	public long srem(String key, byte[]... members);
	
	/**
	 * 将目标元素加入的key索引指向的链表的头部
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long lpush(String key, byte[]... members);
	
	/**
	 * 将目标元素加入的key索引指向的链表的头部
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long lpush(String key, String... members);
	
	/**
	 * 将目标元素加入的key索引指向的链表的头部
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public  <T extends Serializable> long lpush(String key, T... members);
	
	/**
	 * 将目标元素加入的key索引指向的链表的头部
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long lpushx(String key, byte[]... members);
	
	/**
	 * 将目标元素加入的key索引指向的链表的头部
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long lpushx(String key, String... members);
	
	/**
	 * 将目标元素加入的key索引指向的链表的头部
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public  <T extends Serializable> long lpushx(String key, T... members);
	
	/**
	 * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long rpush(String key, byte[]... members);
	
	/**
	 * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long rpush(String key, String... members);
	
	/**
	 * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public  <T extends Serializable> long rpush(String key, T... members);
	
	/**
	 * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long rpushx(String key, byte[]... members);
	
	/**
	 * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public long rpushx(String key, String... members);
	
	/**
	 * 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
	 * @param key                索引的key
	 * @param members            目标袁术
	 * @return
	 */
	public  <T extends Serializable> long rpushx(String key, T... members);
	
	/**
	 * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
	 * @param key                索引的key
	 * @param members            要移除的目标元素 
	 * @return
	 */
	public long srem(String key, String... members);
	
	/**
	 * 将一个或者多个目标元素加入索引为key的集合中
	 * @param key                 索引的key
	 * @param members             一个或者多个元素
	 * @return                    成功加入的元素个数
	 */
	public long sadd(String key, byte[]... members);
	
	/**
	 * 将一个或者多个目标元素加入索引为key的集合中
	 * @param key                 索引的key
	 * @param members             一个或者多个元素
	 * @return                    成功加入的元素个数
	 */
	public long sadd(String key, String... members);
	
	/**
	 * 移除并返回列表 key 的头元素。
	 * @param key                 索引的key
	 * @return
	 */
	public byte[] lpop(String key);
	
	/**
	 * 将列表 key 下标为 index 的元素的值设置为 value,当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误
	 * @param key                 索引的key
	 * @param value               待设置的值
	 * @param index               目标成员下标
	 * @return
	 */
	public boolean lset(String key, byte[] value, long index);
	
	/**
	 * 将列表 key 下标为 index 的元素的值设置为 value,当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误
	 * @param key                 索引的key
	 * @param value               待设置的值
	 * @param index               目标成员下标
	 * @return
	 */
	public boolean lset(String key, String value, long index);
	
	/**
	 * 将列表 key 下标为 index 的元素的值设置为 value,当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误
	 * @param key                 索引的key
	 * @param value               待设置的值
	 * @param index               目标成员下标
	 * @return
	 */
	public <T extends Serializable> boolean lsetBean(String key, T value, long index);
	
	/**
	 * 根据参数 count 的值，移除列表中与参数 value 相等的元素
	 * @param key                 索引的key
	 * @param value               移除待比较的值
	 * @param count               移除的数量
	 * count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。 
	 * count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。 
	 * count = 0 : 移除表中所有与 value 相等的值
	 * @return
	 */
	public long lrem(String key, byte[] value, long count);
	
	/**
	 * 根据参数 count 的值，移除列表中与参数 value 相等的元素
	 * @param key                 索引的key
	 * @param value               移除待比较的值
	 * @param count               移除的数量
	 * count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。 
	 * count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。 
	 * count = 0 : 移除表中所有与 value 相等的值
	 * @return
	 */
	public long lrem(String key, String value, long count);
	
	/**
	 * 移除并返回列表 key 的头元素。
	 * @param key                 索引的key
	 * @return
	 */
	public <T extends Serializable> T lpopBean(String key);
	
	/**
	 * 移除并返回列表 key 的尾元素。
	 * @param key                 索引的key
	 * @return
	 */
	public byte[] rpop(String key);
	
	/**
	 * 移除并返回列表 key 的尾元素。
	 * @param key                 索引的key
	 * @return
	 */
	public <T extends Serializable> T rpopBean(String key);
	
	/**
	 * 从srcKey指向的列表中弹出尾元素，并插入dstKey指向的列表作为头元素，若srcKey不存在，则返回空，忽略后续操作
	 * 若dstKey与srcKey相同，执行后相当于把队尾的数据换到了队头，其他数据后移一个位置
	 * @param scrKey             源索引的key
	 * @param dstKey             目标索引的key
	 * @return
	 */
	public byte[] rpoplpush(String scrKey, String dstKey);
	
	/**
	 * 从srcKey指向的列表中弹出尾元素，并插入dstKey指向的列表作为头元素，若srcKey不存在，则返回空，忽略后续操作
	 * 若dstKey与srcKey相同，执行后相当于把队尾的数据换到了队头，其他数据后移一个位置
	 * @param scrKey             源索引的key
	 * @param dstKey             目标索引的key
	 * @return
	 */
	public <T extends Serializable> T rpoplpushBean(String scrKey, String dstKey);
	
	/**
	 * 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
	 * @param key                 索引的key
	 * @param start               开始下标
	 * @param end                 结束下标
	 * @return
	 */
	public boolean ltrim(String key, long start, long end);
	
	/**
	 * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中
	 * @param key                 索引的key
	 * @param scoreMembers        socre值和元素表
	 * @return                    被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员
	 */
	public long zadd(byte[] key, Map<Double, byte[]> scoreMembers);
	
	/**
	 * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中
	 * @param key                 索引的key
	 * @param scoreMembers        socre值和元素表
	 * @return                    被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员
	 */
	public long zadd(String key, Map<Double, String> scoreMembers);
	
	/**
	 * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中
	 * @param key                 索引的key
	 * @param scoreMembers        socre值和元素表
	 * @return                    被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员
	 */
	public <T extends Serializable> long zaddBean(String key, Map<Double, T> scoreMembers);
	
	/**
	 * 将分页对象加入到有序集合中
	 * @param key                 索引的key
	 * @param items               查询出来的分页对象列表
	 * @param pageNo              页码
	 * @param pageSize            分页大小
	 * @return                    成功加入的数量
	 */
	public <T extends Serializable> long zaddPage(String key, List<T> items, int pageNo, int pageSize);
	
	/**
	 * 为有序集 key 的成员 member 的 score 值加上增量 increment(可正可负)
	 * @param key                  索引的key
	 * @param step                 步长
	 * @param member               目标成员
	 * @return                     成功member增加后的score值
	 */
	public double zincrBy(String key , double step, byte[] member);
	
	/**
	 * 为有序集 key 的成员 member 的 score 值加上增量 increment(可正可负)
	 * @param key                  索引的key
	 * @param step                 步长
	 * @param member               目标成员
	 * @return                     成功member增加后的score值
	 */
	public double zincrBy(String key , double step, String member);
	
	/**
	 * 为有序集 key 的成员 member 的 score 值加上增量 increment(可正可负)
	 * @param key                  索引的key
	 * @param step                 步长
	 * @param member               目标成员
	 * @return                     成功member增加后的score值
	 */
	public <T extends Serializable> double zincrBy(String key , double step, T member);
	
	/**
	 * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略
	 * @param key                  索引的key
	 * @param members              目标成员
	 * @return
	 */
	public long zrem(String key, byte[]... members);
	
	/**
	 * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略
	 * @param key                  索引的key
	 * @param members              目标成员
	 * @return
	 */
	public long zrem(String key, String... members);
	
	/**
	 * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略
	 * @param key                  索引的key
	 * @param members              目标成员
	 * @return
	 */
	public <T extends Serializable> long zrem(String key, T... members);
	
	/**
	 * 移除有序集 key 中，指定排名(rank)区间内的所有成员。
	 * 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。
	 * 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
     * 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
	 * @param key                 索引的key
	 * @param start               起始下标
	 * @param end                 结束下标
	 * @return                    成功移除数量
	 */
	public long zremrangeByRank(String key , long start, long end);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
	 * @param key                 索引的key
	 * @param min                 最小score值
	 * @param max                 最大score值
	 * @return                    成功移除的个数
	 */
	public long zremrangeByScore(String key, double min, double max);
	

}
